Debugging using presentation layer representations of objects

ABSTRACT

Exemplary embodiments enable debugging executable code using a debugger in a computational device that provides a programming environment including a presentation layer. For example, an exemplary method includes providing a first marshalling function that receives a portion of information manipulated by the executable code and produces a presentation layer representation of the portion of the information. The presentation layer representation is compatible with a debugger that debugs the executable code. An exemplary method also includes debugging the executable code to produce a presentation layer representation of the portion of the information with the first marshalling function so as to display the presentation layer representation of the portion of the information to a user via a display device. The debugging also includes modifying the presentation layer representation of the portion of the information to produce modified information for use by the executable code, a device, or a user.

RELATED APPLICATIONS

This application claims the benefit of a United States Provisional Application entitled “Debugging Using Presentation Layer Representations of Objects” filed on Jul. 13, 2007, Ser. No. 60/959,466, the contents of which is incorporated herein by reference in its entirety.

BACKGROUND

A debugger is software that identifies “bugs” in a program as the program is developed. As used herein a “bug” is any behavior in a program that is not what the program is intended to do. The debugger further helps a programmer to fix program code that does not operate in a desired manner. Typically, a debugger allows the programmer to monitor the program as the program executes. The programmer may modify instructions in the program using the debugger. Furthermore, the programmer may use the debugger to modify values stored in memory for the program.

The debugger may further allow the programmer to start and stop execution of the program in multiple ways. For example, the debugger may enable the programmer to insert breakpoints in the program that halt execution of the program at the locations where the breakpoints are inserted. The debugger may further allow the programmer to view values of variables and other objects at the breakpoints. For example, the programmer can view the state of the program at each breakpoint and thus, gather valuable information regarding how the program behaves.

The debugger may further allow the programmer to start and stop program execution via a technique called “single stepping.” With single stepping, a single statement in the program is executed then program execution is halted. Then, the next statement is executed and program execution is halted. This process may repeat as long as single stepping is active or until the end of the program is reached.

Debuggers may require that the program be available in executable form for the program to be executed. In many instances, a compiler will generate this executable form of the program. The compiler builds a symbol table when compiling the program. The symbol table is a data structure that holds information regarding each identifier in the program. The information may include type, size, and memory location of each object that is identified by an identifier in the program and is specific to the programming language in which the program is written.

The debugger may access information in the symbol table to display information regarding an object in the program. For example, the debugger may display a value for an object when program execution is halted. To display the object's value, the debugger may need to locate and read the language-specific representation of the value of the object which is stored in memory, and convert the information into a representation that the debugger can understand (e.g. a “source code representation”). Based on the information in the symbol table, the debugger determines the data type (language-specific), size and memory location of the representation of the object. The debugger reads the value of the language-specific representation of the object at the memory location specified by the symbol table. The debugger uses the type definition for the type specified for the object in the symbol table to format and display the value of the object. A debugger may use its own conversion to read from the symbol table to convert the language-specific representation of the object to source code representation. The debugger then displays the source code representation of the object using a presentation layer in the debugger, where the presentation layer is a component that displays information to the user and/or that accepts information from the user.

In addition to accessing the symbol table to display a value of an object, the debugger may also access the symbol table to modify a value of an object when program execution is halted. For example, when the programmer provides a modified value of an object (such as a variable) through the presentation layer of the debugger, the debugger receives the value in a format that is native to the debugger (e.g. the source code representation). The debugger uses the information in the symbol table and the debugger's conversion function to convert the modified value in the source code representation of the object into a corresponding modified value of the language-specific representation of the object.

SUMMARY

An exemplary embodiment provides a method for debugging a program using a debugger in a computational device including a display and a memory, where the computation device provides a programming environment including a presentation layer. The method includes obtaining a first language-specific representation of an object from the memory. The method also includes obtaining a first presentation layer representation of the object, and using the first presentation layer representation of the object in the debugger to display information about the object to a user.

According to further aspects of an exemplary embodiment, obtaining a first presentation layer representation of the object may include creating a first presentation layer representation of the object in memory using a first marshalling function. Obtaining a first presentation layer representation of the object may include performing an operation on the first language-specific representation of the object, the operation creating a first presentation layer representation of the object in the memory. The first presentation layer representation may be a programming language-independent representation, where a programming language-independent representation is not specific to a programming language of the program being debugged. The first presentation layer representation may be a programming environment presentation layer representation. The operation on the first language-specific representation of the object may be performed by a first marshalling function.

According to other aspects of an exemplary embodiment, the method may further include instructing a compiler to generate at least one marshalling function, the at least one marshalling function including the first marshalling function. The at least one marshalling function may be automatically generated by a compiler when a source program is compiled in a debug mode, where the at least one marshalling function includes the first marshalling function. The at least one marshalling function, which converts between a language-specific representation of the object and a presentation layer representation of the object, may be generated by an interpreter. The at least one marshalling function, which converts between a language-specific representation of the object and a presentation layer representation of the object, may be generated by a translator.

According to further aspects of an exemplary embodiment, the method may further include loading and executing the at least one marshalling function in a processing environment of the program. The method may further include loading and executing the at least one marshalling function in a separate processing environment from a processing environment of the program.

According to another aspect of an exemplary embodiment, using the first presentation layer representation of the object in the debugger may include displaying the first presentation layer representation of the object in a graphical user interface (GUI) while the program is executing, where the GUI is associated with the presentation layer.

According to other aspects of an exemplary embodiment, the method may also include creating a second presentation layer representation of the object by altering the first presentation layer representation of the object, obtaining an altered first language-specific representation of the object corresponding to the second presentation layer representation of the object, executing the program using the altered first language-specific representation of the object. Obtaining an altered first language-specific representation of the object may include creating an altered first-language specific representation of the object using a second marshalling function. Obtaining an altered first language-specific representation of the object may include operating on the second presentation layer representation of the object to produce an altered first language-specific representation of the object. The operation on the second presentation layer representation of the object may be performed by a second marshalling function.

An exemplary embodiment provides a method for debugging executable code. The method includes providing a first marshalling function for use with the executable code. The first marshalling function receives a portion of information manipulated by the executable code and produces a presentation layer representation of the portion of the information. The presentation layer representation of the portion of the information is compatible with a debugger that debugs the executable code. The method also includes debugging the executable code. The debugging includes producing a presentation layer representation of the portion of the information with the first marshalling function to display the presentation layer representation of the portion of the information to a user via a display device. The debugging may also include displaying the presentation layer representation of the portion of information in a graphical user interface (GUI) associated with a presentation layer of a programming environment, according to an aspect of an exemplary embodiment. The debugging also includes modifying the presentation layer representation of the portion of the information to produce modified information for use by the executable code, a device, or a user. The method may be implemented on a computing device with a programming environment including a presentation layer.

According to aspects of an exemplary embodiment, the debugging may further include sending the portion of the information to a destination, wherein the portion of the information is sent using the presentation layer representation of the portion of the information or using another representation of the portion of the information that differs from the presentation layer representation. The debugging may also include storing the presentation layer representation of the portion of the information in a storage device.

The method may also include providing a second marshalling function for use with presentation layer representations of information, wherein the second marshalling function receives a presentation layer representation of information and produces corresponding information in a format compatible with the executable code. The debugging may include producing modified information from the modified presentation layer representation with the second marshalling function and modifying the executable code using the modified information.

According to other aspects of an exemplary environment, the method may also include instructing a compiler to generate at least one marshalling function, where the at least one marshalling function includes the first marshalling function. The method may further include compiling a program in a debug mode using the debugger to generate one or more marshalling functions that include the first marshalling function.

Another aspect of an exemplary embodiment is a medium for use with a computing device holding instructions executable by the computing device for debugging a program using a debugger by performing any of the aforementioned methods.

Yet another aspect of an exemplary embodiment includes a system for debugging a program using a debugger. The system includes an electronic device with a display and memory. The system also includes a programming environment with a presentation layer. The system further includes a debugger that includes a retrieving mechanism for obtaining a language specific representation of an object in the memory and a representation conversion mechanism for using the language-specific representation of the object in the memory to obtain a presentation layer representation of the object in the memory. The debugger also includes a display mechanism for using the presentation layer representation of the object to display information about the object to a user.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate one or more embodiments of the invention and, together with the description, explain the invention. In the drawings,

FIG. 1A schematically illustrates a program, a conventional debugger for debugging the program, a conventional symbol table associated with the program, and a display to display information about program objects;

FIG. 1B schematically illustrates displaying a value of a program data object using a debugger of the prior art;

FIG. 2A schematically illustrates an exemplary embodiment that allows a user to interact with program objects;

FIG. 2B schematically illustrates displaying a value of a program data object using an exemplary embodiment of a debugger;

FIG. 3A is a schematic diagram of an exemplary programming environment that includes an exemplary debugger;

FIG. 3B is a schematic diagram of a programming environment and an exemplary debugger in which the debugger is outside the programming environment;

FIG. 3C is a schematic diagram illustrating the interaction of various computer language compilers and a debugger according to an exemplary embodiment;

FIG. 4A illustrates a portion of the user interface for an exemplary debugger, according to an aspect of an exemplary embodiment;

FIG. 4B illustrates a command window in which a user may request display of a value of a program variable, according to an aspect of an exemplary embodiment;

FIG. 4C illustrates a command window in which a user may alter a value of a first presentation layer representation of a variable, according to an aspect of an exemplary embodiment;

FIG. 5 is a schematic diagram illustrating operation of a first and a second marshalling function, according to another aspect of an exemplary embodiment;

FIG. 6A is a flow chart illustrating a technique for debugging a program according to an aspect of an exemplary embodiment;

FIG. 6B is a flow chart illustrating alternative techniques that may be used for debugging a program that allow a user to modify run-time values during execution, according to further aspects of an exemplary embodiment;

FIG. 6C is a flow chart illustrating a technique for debugging a program using marshalling functions, according to aspects of an exemplary embodiment;

FIG. 6D is a flow chart illustrating steps that may be included in the technique depicted in FIG. 6C, according to aspects of an exemplary embodiment;

FIG. 7A is a schematic diagram of an exemplary computing device for practicing exemplary embodiments;

FIG. 7B depicts an exemplary distributed system suitable for practicing a distributed implementation of an exemplary embodiment; and

FIG. 8 is a schematic diagram of an exemplary system for debugging that includes a retrieving mechanism, a representation conversion mechanism, and a display mechanism, according to aspect of an exemplary embodiment.

DETAILED DESCRIPTION

A conventional debugger that supports a specific language may be configured to recognize all the object “types” generated by the compiler for the specific language. Information regarding the “type” of each object in a program may be stored in a symbol table that is associated with the program and generated by the compiler. For example, a conventional debugger may need to work with all of the object “types” that may appear in the symbol table to format and display a given program object value. As the specific language is modified to include a new object type, the conventional debugger may be modified to work with the new object types. If a debugger needs to support a new language with a type system that differs from a type system of the language (or languages) that the debugger currently supports, then the debugger may need to be modified to support the new language. Thus, conventional debuggers that directly support language-specific object types may be sensitive to changes in supported languages and may be limited in the number of languages that any one debugger can support.

In contrast, a debugging technique (e.g., a debugging method) of an exemplary embodiment may use a target-language compiler to create marshalling functions that convert between language-specific representations of data objects and presentation-layer representations of data objects. For example, one embodiment may directly convert between language specific representations and presentation layer representations of data objects. This direct conversion may eliminate the need for language-specific conversion functions in the debugger. In a debugging technique of an exemplary embodiment, display and manipulation occurs with the data objects in the form of presentation-layer representations. Presentation-layer representations are opaque data objects, meaning that the presentation-layer representations of data objects may all behave in the same manner, regardless of the language of the program source code being debugged. Because an exemplary debugging technique works with opaque presentation-layer representations of data objects, the debugger does not need to know the details associated with the language-specific object types. For example, the debugger may work with any compiler where the debugger has access to suitable conversion operations for converting to and from opaque representations of data objects and language-specific representations of data objects produced by the compiler. Suitable conversion operations include an operation that produces a presentation layer (opaque) representation of an object from a language-specific representation of the object and an operation that produces a language-specific representation of an object from an (opaque) presentation layer representation of the object.

According to an aspect of an exemplary embodiment, the compiler for a target programming language may be used to produce marshalling functions which perform the aforementioned operations. A debugging technique of an exemplary embodiment is flexible, because modifications to object types in languages supported by the debugging technique, or incorporation of new languages to be supported by the debugging technique, does not require modification of the debugging technique. Unlike conventional debuggers that usually require specific knowledge of the type system of the target language, an exemplary debugging technique may automatically support multiple languages, multiple compilers and/or multiple type systems because the exemplary debugging technique works with opaque data types that are programming language independent.

An exemplary embodiment may reduce the overhead associated with a conventional debugger when used in a programming environment that includes a presentation layer. Some programming environments include a presentation layer for the creation and manipulation of data objects. Conventional debuggers typically include a data object presentation layer, which is separate from the presentation layer of the programming environment. A conventional debugger that includes a data object presentation layer in addition to the presentation layer of the programming environment may result in large overhead for an overall system that includes the debugger and the programming environment due to the two separate data object presentation layers. In contrast, an exemplary embodiment may eliminate the need for a separate presentation layer in the debugger by leveraging the presentation layer of the programming environment. For example, an exemplary embodiment may employ a debugger that uses the presentation layer of the programming environment to display and/or modify objects of a program under test. Each language supported by the programming environment can have language-specific mechanisms for converting between presentation-layer representations of objects and language-specific representations stored in memory. These language-specific mechanisms may allow the debugger to deal only with opaque objects passed between the presentation layer and the program under test, where opaque objects are not language-specific. The use of opaque objects may relieve the debugger from having to directly support language-specific object representations and/or language-specific types.

Exemplary embodiments may allow a debugger to support many different programming languages without requiring that the debugger directly support each language-specific type in every supported language. Because the debugger does not directly support language-specific types the debugger may be more reliable, easier to write and more extensible than conventional debuggers. In addition, because the debugger does not directly support language-specific types the debugger may be faster than conventional debuggers. In a programming environment with a presentation layer, the debugger may reduce overhead that is associated with a separate debugging presentation layer for conventional debuggers.

Executable code manipulates information when run. As used herein, a data object is any portion of said information that a programmer or user would like to access, view or modify in the debugging process. Examples of portions of information contained in executable code that are data objects include, but are not limited to, values of variables, constants, etc.

FIG. 1A schematically illustrates a program “P” 12, a conventional debugger 20 for debugging program 12, a conventional symbol table 16 associated with the program 12, and a display 18 to display information about program objects. A conventional debugger may acquire and display a value of a program object (such as a variable) during halted execution of a program. In FIG. 1A, exemplary program 12 that includes object “X” 30 is being executed on a computing device with memory 14 and a display 18. During execution, a language-specific representation 32 of object 30 is stored in the memory 14. Conventional debugger 20 has access to conventional symbol table 16 associated with program 12. If program 12 has been compiled, conventional symbol table 16 may have been generated by a compiler when program 12 was compiled. Conventional symbol table 16 may contain information relating to one or more data objects in program 12, such as the object name 17 a, the object type 17 b, the location of the value of the object in memory 17 c, and the size of the object in memory 17 d. Conventional debugger 20 may include two built-in conversion functions for each object type in the language supported by the debugger 20. For a specific object type, one built-in conversion function 22 a converts a language-specific (LS) representation of an object to a source code (SC) representation of the object, and the other built in conversion function 22 b converts the source code representation of the object to the language-specific representation of the object. Conventional debugger 20 also includes debugger presentation layer 24 for displaying a value of an object.

FIG. 1B schematically illustrates the conventional debugger 20 acquiring a value of program object 30 and displaying a presentation layer representation 38 of object 30 on the display 18. During debugging, execution of program 12 may be halted and a programmer may request to see a value of program object 30. In response, conventional debugger 20 will read information from conventional symbol table 16 including the object type 17 b, and the address 17 c of the location of a language-specific representation 32 of object 30 in memory 14. Debugger 20 then goes to the address 17 c in memory 14 and reads the value of language-specific representation 32. Debugger 20 creates a source code representation 34 of the object 30 by sending language specific representation 32 read from memory 14 and the object type 17 b read from conventional symbol table 16 to the LS to SC conversion function 22 a. The LS to SC conversion function 22 outputs a source code representation 34 of object 30. The dotted box indicates that source code representation is not an element of conventional debugger 20, but is created by conventional debugger 20 during debugging. Source code representation 34 is then sent to debugger presentation layer 24 which displays a presentation layer representation 38 of object 30 on the display 18. Conventional debugger 20 may include built in LS to SC conversion functions 22 a and SC to LS conversion functions 22 b for all object types in all supported program languages. Changes to object types in a supported program language may require modification of conversion functions or addition of new conversion functions to conventional debugger 20 because conversion functions 22 a and 22 b are specific to the object types of the supported program languages. Conventional debugger 20 may require a debugger presentation layer 24 to display presentation lay representation 38 on the display 18.

FIG. 2A schematically illustrates a program 62, an exemplary debugger 70 for debugging program 62, an exemplary symbol table 66 associated with program 62, a programming environment presentation layer 69 and a display 68 to display information about program objects. Program 62 includes object “X” 30. A language-specific (LS) representation 32 of object 30 is stored in memory 64. Memory 64 also holds a conversion function that converts the language-specific representation 32 of the object to a presentation layer (PL) representation of the object, LS to PL conversion function 65 a, and a conversion function that converts the presentation layer representation of the object to the language-specific representation 32 of object 30, PL to LS conversion function 65 b. Exemplary symbol table 66 includes the object name 67 a, the location 67 b of the object in memory 64, and locations 67 c of conversion functions in memory. Exemplary debugger 70 is depicted in communication with a programming environment presentation layer 69. In contrast to conventional debugger 20, exemplary debugger 70 does not include conversion functions between a language-specific representation and a source code representation (LS to SC and SC to LS). In further contrast to conventional debugger 20, exemplary debugger 70 does not include a presentation layer separate from programming environment presentation layer 69.

FIG. 2B schematically illustrates exemplary debugger 70 acquiring a value of program object 30 and displaying a presentation layer representation 39 of object 30 on the display 68. When the programmer requests display of the value of program object 30 while program execution is halted, debugger 70 reads information from the symbol table 66 associated with the program 62. The symbol table 66 contains information about each object including the name 67 a, and the location of the object in memory 67 b. In this instance, the symbol table 66 also contains a location 67 c of LS to PL and PL to LS conversion functions 65 a, 65 b in memory 64. The debugger 70 reads the location of X in memory 67 b and the location 67 c of the LS to PL conversion function 65 a for object 30. The LS to PL conversion function 65 a for object 30 implicitly includes information regarding the type of object 30 and the size of object 30 in memory, thus, the object type of X and size of X need not be directly stored in the symbol table 66. The debugger 70 then reads in the value of language specific representation 32 stored in memory 64 and sends language-specific representation 32 to LS to PL conversion function 65 a. LS to PL conversion function 65 a outputs a presentation layer representation 39 of object 30. The debugger 70 sends presentation layer representation 39 to the programming environment presentation layer 69 and instructs the programming environment presentation layer 69 to display presentation layer representation 39 on the display 68.

The exemplary debugger 70 of FIG. 2B may not include any conversion functions to convert between different representations of the object. Conversion functions that convert between different representations of the object may be generated outside of exemplary debugger 70 and accessed by exemplary debugger 70 without being included in exemplary debugger 70. The LS to PL and PL to LS conversion functions 65 a, and 65 b are associated with the compiled program 62 and can be generated by a compiler that was used to compile the program. Because exemplary debugger 70 does not include language-specific conversion functions, changes in supported object types may not necessitate changes to exemplary debugger 70.

The exemplary debugger 70 may not include a presentation layer. Instead the exemplary debugger 70 uses the programming environment presentation layer 69 to display the presentation layer representation 39 of object 30. The dotted boxes around language specific representation 32 and presentation layer representation 39 indicate that these representations are generated or used in exemplary debugger 70 and display 68, but are not components of exemplary debugger 70 or display 68. The dotted boxes also indicate that the language-specific representation 32 and the presentation layer representation 39 are not residing in debugger 70, but that debugger 70 has access to an address in memory of language-specific representation 32 and presentation layer representation 39, access to an address in memory of a copy of language-specific representation 32 and presentation layer representation 39, and/or a copy of values of language-specific representation 32 and presentation layer representation 39.

An exemplary embodiment may be related to a programming environment 307 as illustrated in FIG. 3A. Programming environment 307 supports the design and modification of applications and other executable processes (e.g., code). Programming environment 307 may be command line driven and/or graphical. In programming environment 307, programs are written in one or more languages that may be any of textual/or graphical. Programming environment 307 may also support any of compiling, debugging, translating, executing, running, and simulating an application or other executable process as well as supporting presentation of program information. Exemplary programming environments may include environments provided by the MATLAB and SIMULINK software of The MathWorks, Inc, as well as environments provided by other manufacturers.

Programming environment 307 may include a presentation layer 305. A presentation layer, as used in this context, is a software component that displays information to a user or accepts input from a user. A presentation layer representation of an object is the representation that the presentation layer can use to serialize the object to and from a graphical user interface 715, a network interface 718, a storage 708, and other devices such a computer monitor, a keyboard, the installation medium 716, a disk drive, a printer etc (see also FIG. 7A). For example, in one embodiment, the presentation layer can directly serialize the object. An example of a presentation layer representation is an mxArray in MATLAB.

Programming environment 307 may also include one or more compilers 315. A compiler 310, as incorporated into an exemplary embodiment, is a computer program or set of programs that translates text and/or syntax written in a computer language (the source language) into another computer language (the target language). The original sequence may be called the source code and the output may be called the object code. For example, compiler 310 may translate source code from a high level language (e.g., C, C++, Perl, etc.) to a lower level language (e.g., object code, etc.). Compiler 310 may include a program or programs that translate between high level languages (also known as language translators, source to source translators and language converters). An exemplary embodiment may incorporate any of a native-code compiler, which generates output intended to run on the same type of computer and operating system (platform) as the compiler itself runs on, a cross-compiler, which generates output designed to run on a different platform than that of the compiler, and/or a virtual machine compiler. Additionally, an exemplary embodiment also encompasses interpreters. An interpreter directly executes a high level program without preliminary translation into machine code.

As depicted in FIG. 3A, a debugger 310 operates within programming environment 307. Alternately, debugger 310 may operate from outside the programming environment 307 as illustrated in FIG. 3B. Again, programming environment 307 includes a presentation layer 305 and one or more compiler(s) 315. Debugger 310 operates from outside programming environment 307 and communicates with programming environment 307.

FIG. 3C illustrates the connection between a debugger 310 and compilers 310 for various languages, according to an aspect of an exemplary embodiment. Debugger 310 may operate from within the programming environment 307 as depicted in FIG. 3A or may operate from outside the programming environment 307 as depicted in FIG. 3B. As depicted in FIG. 3C, exemplary debugger 310 may work with compilers for a variety of languages such as: an embedded MATLAB compiler 310 a, a Visual C++® compiler 310 b, a JAVA® compiler 310 c, a Visual FORTRAN compiler 310 d, a G++ compiler 310 e and an SDK compiler 310 f. For example, debugger 310 may be used to debug programs written in different programming languages, such as MATLAB programming language, Visual C++®, a JAVA®, FORTRAN, etc. Debugger 310 may use opaque data objects and may not directly support language specific data objects. As a result, exemplary debugger 210 may support any number of different languages and need not be modified when object types in the supported programming languages are modified or added.

An example programming environment, the Simulink® software product, from The MathWorks, Inc. of Natick, Mass., provides a graphical modeling environment and programming environment with a presentation layer. Within SIMULINK, users may employ Embedded MATLAB language (EML) to define the function of a “block” program written in EML that may be compiled, debugged and run by a user within the SIMULINK environment. The EML program may be compiled from EML into C code by the EML compiler. The EML compiler may produce marshalling functions that convert between a C representation of an object and a MATLAB representation of that object.

FIG. 4A depicts a portion of a user interface 400 for a programming environment 307 that can be used with debugger 310. A sample program depicted in FIG. 4A that consists of one function (an identity function) is used in describing debugger 310. The program to be debugged (the identity function) is displayed in program window 402. An identity function in the MATLAB M programming language is a function that given an object will return a copy of the object:

function y=identity(u)

y=u;

The identity M function is a polymorphic function meaning that it can take an object of any data type as input. The embedded MATLAB language (EML) compiler can be used to compile the identity M function to C code that accepts only a particular data type, such as a real, scalar value of class double.

FIGS. 4B and 4C depict a command window 410 and illustrate displaying a value of a program object and changing a value of a program object respectively. When program execution is stopped in debugger 310, the programmer may request display of an object's value through the graphical user interface. The programmer may request display by hovering over a symbol corresponding, by employing a mouse cursor, by typing the object's name and/or may use other suitable techniques. In FIG. 4B a programmer has requested display of the value of object “u” by typing the object's name (“u”) 412 in command window 410. In response, a value of object “u” 414 is displayed in the command window 410. In FIG. 4C a programmer has entered a different value 416 for object “u”. Command window 410 displays output 418 indicating that the different value 416 has been assigned to object “u”.

In FIGS. 4A and 4B, when the programmer requests display of the program object “u”, the programmer calls the compiled language-specific (e.g., C) version of the identity function from a programming environment (e.g., a programming environment provided by MATLAB software) and wants the result of the function call displayed in the presentation layer of the programming environment. The programming environment representation of an object, such as object “u”, is a presentation layer representation. For example, the programming environment provided by MATLAB software is designed to display MATLAB representations of objects. The language-specific representation of an object, such as object “u”, stored in memory may also be referred to as a run-time representation of the object. As depicted in FIGS. 2A and 2B exemplary debugger 70 uses a LS to PL conversion function 65 a and a PL to LS conversion function 65 b to convert between a language specific representation 32 and a presentation layer representation 39 of an object. An exemplary debugger may use marshalling functions to convert between representations of program objects for displaying values of the program objects and allowing users to change runtime values of the program objects. A marshalling function converts between different representations of an object. For example, the Embedded MATLAB Coder Compiler (EMCC) uses marshalling functions to convert between a MATLAB representation of an object and a C runtime representation of the object.

FIG. 5 is a schematic diagram illustrating two complimentary marshalling functions according to aspects of an exemplary embodiment. A variable “A” exists as a language-specific representation of an object in computer memory 500. The address in memory of the language-specific representation of “A” is passed to a first marshalling function 505. The first marshalling function 505 produces an address of a presentation layer representation of “A” 510. The debugging technique may then use the presentation layer representation of “A” 510 for displaying and modifying the variable while the program is executing. The second (complimentary) marshalling function 525 takes the address of a presentation layer representation of an object “B” and the name of the object 520 as input and returns the address of the language-specific representation of “B” as an output 530. Second marshalling function 525 may then be used to change a value of a language-specific representation of a variable based on changing the value of a presentation layer representation of the variable.

For example, marshalling from a C (language-specific) data format for a real scalar double to a MATLAB (presentation layer) data format (as required for the example program presented above) may be implemented using the following C function:

01 static const mxArray *m_emlrt_marshallOut(real_T eml_u)

02 {

03 const mxArray *eml_y;

04 const mxArray *eml_m0;

05 eml_y=NULL;

06 eml_m0=mxCreateDoubleScalar(eml_u);

07 emlrtAssign(&eml_y, eml_m0);

08 return eml_y;

09 }

First marshalling function 505 takes only one input; the C (language-specific) representation of a real, scalar double, which is type real_T. First marshalling function 505 converts the C representation to the MATLAB (presentation layer) representation using a MATLAB support function. First marshalling function 505 then returns the MATLAB representation, which is an mxArray.

A different second marshalling function 525 is used to marshal from the MATLAB (presentation layer) representation for a real, scalar double to the C (language-specific) format. The second marshalling function 525 may be implemented using the following C function:

01 static real_T_m_b_emlrt_marshallIn(const mxArray *eml_src, char *eml_nam)

02 {

03 real_T eml_ret;

04 emlrtCheckBuiltIn(eml_nam, eml_src, “double”, false, 0U, 0);

05 eml_ret=*(real_T *)mxGetData(eml_src);

06 emlrtDestroyArray(&eml_src);

07 return eml_ret;

08 }

This second marshalling function takes two inputs: a pointer to the MATLAB representation of a real, scalar double, which is an mxArray, and the MATLAB name of an object being marshalled. The second marshalling function returns the C representation of a real, scalar double, which is real_T. The second marshalling function first verifies that the input object is of the expected type, a real, scalar double, then uses a MATLAB support function to extract the value in C format. Marshalling functions are just one example of a technique to implement “opaque” data objects for use in a debugger according to aspects of an exemplary embodiment. When viewing and manipulating “opaque” data objects, the debugger may not need to have information about how to display objects that are different variable types because “opaque” data objects, which are presentation layer representations of objects, may already be formatted for display.

FIG. 6A is a flowchart depicting the steps performed in debugging a program using a debugger in a computing device that provides a programming environment with a presentation layer according to an exemplary embodiment. In FIGS. 6A to 6D dotted outlines indicate steps that may be performed as part of a debugging technique or process, according to aspects of an exemplary embodiment. The steps are discussed with respect to exemplary programming environment 307 depicted in FIG. 3A and exemplary debugger 70 depicted in FIGS. 2A and 2B solely for illustrative purposes.

During halted execution of program 62, a programmer requests display of a value of a program object 30. Objects used by the program 62 being debugged are stored in memory 64. Initially, a first language-specific representation 32 of an object 30 in memory 64 is obtained (step 610). A location 67 b of language-specific the representation 32 of object 30 in memory 64, and a location 67 c of LS-PL conversion functions 65 a, 65 b in memory 64 may be read from the exemplary symbol table 66, and then language-specific representation 32 may be read from memory 64 at the specified location 67 b.

A first presentation layer representation 69 of the object in memory 64 is obtained (step 612). Obtaining a first presentation layer representation 69 of the object in the memory 64 (step 612) may include an operation performed on the first language-specific representation 62 of the object, the operation creating a first presentation layer representation 69 of the object in the memory (step 612 a). The operation may include sending the language-specific representation 32 of the object to the LS to PL conversion function 65 a, which outputs presentation layer representation 39 as depicted in FIG. 2B. According to aspects of an exemplary embodiment, the first presentation layer representation 39 of the object in the memory 64 may be created using a first marshalling function 505 (step 612 b), which is illustrated in FIG. 5.

According to other aspects of an exemplary embodiment, a compiler may be instructed to generate at least one marshalling function on demand (step 611). Although, instructing the compiler to generate marshalling functions (step 611) is depicted in FIG. 6A as occurring after a first language-specific representation 32 is obtained (step 610) and before a first presentation layer representation 69 is obtained (step 612), the compiler may be instructed to generate marshalling functions at a different point the debugging technique or at multiple points in the debugging technique. For example, the compiler may be instructed to generate at least one marshalling function before beginning other steps in debugging, and/or the compiler may be instructed to generate marshalling functions in the midst of the other debugging steps.

The compiler may be instructed to generate marshalling functions for less than all of the data types in the program. Any given application may have an arbitrarily large number of data types, particularly if the programming language supports user-defined types. It may not always be desirable to instruct the compiler to pre-generate marshalling functions for all data types in the source program. Instead, the debugger may invoke the target compiler on demand to compile only the needed marshalling functions, which may then be cached and associated with the program under test. According to other aspects of an illustrative embodiment, at least one marshalling function, which includes the first marshalling function, may be automatically generated by a compiler when a source program is compiled in a debug mode. An exemplary embodiment may include both “automatic” marshalling function generation and “on demand” marshalling function generation. For example, some marshalling functions may be “automatically” generated when a source program is compiled, and some marshalling functions may be generated “on demand” only if needed.

The compiler that is instructed to generate at least one marshalling function may include a translator and/or an interpreter. As discussed above, the term “compiler” as used herein refers to a program or programs that translate source code from a high level language to a lower level language, and a program or programs that translate between high level languages including translators, language converters and interpreters.

The generated marshalling functions may be stored in the load file of the program. The symbol table 66 of the program may include the addresses of the marshalling functions associated with each object in the program allowing the debugger to locate the relevant marshalling functions for any of the objects by accessing the symbol table 66. Alternately, the symbol table 66 may only include the addresses of the marshalling functions that have been generated if marshalling functions have not been generated for all of the objects in the program. Additionally, the marshalling functions may be loaded and executed in the same processing environment as the program under test, and/or the marshalling functions may be loaded and executed in a separate processing environment. Thus, for example, if the target processing environment is a memory constrained embedded system, no space need be used for marshalling functions if an alternate processing environment, such as simulator, is available.

After the presentation layer representation 39 is obtained, exemplary debugger 70 uses the presentation layer representation 39 of the object to display information about the object 30 on the display 68 (step 614). Using the first presentation layer 39 representation of the object in the debugger 70 to display information about the object 30 on the display 68 (step 614) may include displaying the first presentation layer representation 39 of the object in a GUI while the program 62 is executing (step 614 a). Exemplary debugger 70 may use the programming environment presentation layer 69 to display the presentation layer representation 39 of the object on the display 68.

FIG. 6B is a flowchart depicting additional steps that may be performed for debugging a program. In addition to displaying information about an object, a debugger may enable a programmer to change the value of a program object during execution. After the first presentation layer representation of the object in the debugger is used to display information about the object to a user (step 614), the first presentation layer representation of the object may be altered to create a second presentation layer representation of the object (step 616). An altered first language specific-representation of the object corresponding to the second presentation layer representation of the object may be obtained (step 618). As depicted in FIG. 6D, obtaining an altered first language-specific representation of the object corresponding to the second presentation layer representation of an object (step 618) may include performing an operation on the second presentation layer representation of the object, the operation creating an altered first language-specific representation of the object (step 618 a) and/or creating an altered first language-specific representation of the object using a second marshalling function (step 618 b). Additionally, the execution of the program may continue using the altered first language-specific representation of the object (step 620). This technique allows a user to modify the value of a presentation layer representation of an object during execution and have the program resume execution using a correspondingly altered language-specific value of the object.

The exemplary technique of FIG. 6B is described for illustrative purposes with reference to the simple program of compiled C code (the identity function described previously) executed within the MATLAB programming environment. As illustrated in FIG. 4C, a user may enter a different value 416 for presentation layer (MATLAB) representation of the object (“u”) by entering a new assignment statement in the command line (as shown), or by any other suitable technique for entering information using a GUI (step 416), which results in an altered value 418 of the presentation layer representation of the object. The debugger 70 may then consult a symbol table 66 to locate the address 67 c in memory of a second marshalling function 525 associated with the object (“u”) and the address 67 b in memory of the language-specific (run-time C) representation of the object (“u”). As discussed above, second marshalling 525 (an example of a PL to LS conversion function 65 b depicted to FIG. 2B) is a marshalling function that converts a presentation layer representation of an object to a corresponding language-specific representation of the same object for a particular object type. The debugger 70 then passes the name of the object “u” and the address of the value of the altered presentation layer (MATLAB) representation to second marshalling function 525. Second marshalling function 525 returns an altered language-specific (C language) value corresponding to the altered presentation layer value. The address in memory of the value of the language-specific (run-time C) representation of “u” is assigned the changed language-specific (C language) value, which sets the language-specific (run-time C) representation to have the altered language-specific value, corresponding to steps 618 and 618 b. When the program resumes execution, it uses the altered language-specific (run-time C) representation value, corresponding to step 620.

FIG. 6C is a flowchart depicting the steps performed in debugging a program using a debugger, according to aspect of an exemplary embodiment. As described above, executable code manipulates information. A data object is any portion of said information that a programmer or user would like to access, view or modify in the debugging process. An exemplary debugging technique may be performed on a computing device having a programming environment 307 that includes a presentation layer 305. Initially, a first marshalling function that receives a portion of information that is manipulated by the executable code and produces a presentation layer representation of the portion of the information is provided (step 630). The presentation layer of the portion of the information is compatible with the debugger. According to aspects of an exemplary embodiment, a second marshalling function that receives a presentation layer representation of information and produces corresponding information in a format compatible with the executable code may also be provided (step 636). The presentation layer representation of the portion of information and the presentation layer representation of the corresponding information may be compatible with the presentation layer 305 of the programming environment 307.

The executable code is debugged (step 638). A presentation layer representation of a portion of information is produced using the first marshalling function (step 640), where the portion of information is a portion of the information manipulated by the executable code. The presentation layer representation of a portion of the information may be displayed in a graphical user interface (GUI) associated with the presentation layer 305 of the programming environment 307.

The presentation layer representation of the portion of the information is modified to produce modified information (step 644). The modified information may be produced from the modified presentation layer representation using the second marshalling function (step 646). The modified information may be used to modify the executable code (step 648). The modified information may be sent to a destination using the presentation layer representation of the modified information or using another representation of the modified information that differs from the presentation layer representation (step 650). The presentation layer representation of the portion of the information or of the modified information may be stored in a storage device (step 652).

FIG. 6D depicts two steps that may be included in providing a first marshalling function (step 630), according to aspects of an illustrative embodiment. Code may be compiled in debug mode to generate one or more marshalling functions where the one or more marshalling functions include the first marshalling function (step 632). Marshalling functions may be generated for all of the data types of the portions of information manipulated by the executable code during code compiling in debug mode. Alternatively, marshalling functions may be generated for only a predetermined set of the data types that includes less than all of the data types of the portions of information manipulated by the executable code during code compiling in debug mode. The predetermined set may be based on user or programmer input or may be a default predetermined set. A compiler may be instructed to generate at least one marshalling function where the at least one marshalling function includes the first marshalling function (step 634). The instruction to the compiler may be “on demand” in response to input from a user, a programmer or another source which identifies which marshalling functions to generate.

Another exemplary embodiment may include a computer-readable medium holding executable instructions that when executed debug executable code. The executable instructions may include instructions for performing any of the exemplary debugging techniques described herein, or any other techniques falling within the scope of the invention. The instructions may be executed on a computing device as described with respect to FIG. 7A.

FIG. 7A depicts an environment suitable for practicing an exemplary embodiment. The environment includes a computing device 702 having memory 706, on which software according to one exemplary embodiment may be stored, a processor (CPU) 704 for executing software stored in the memory 706, and other programs for controlling system hardware. Optionally, the computing device 702 may include multiple CPUs 704 for executing software loaded in the memory 706, and other programs for controlling system hardware. Each of the CPUs may be a single or a multiple core processor 705 a, 705 b.

Computing device 702 may support any suitable device readable medium 716 for installing software programs, such as a CD-ROM, DVD-ROM, floppy disk, tape device, USB device, hard-drive, etc. Computing device 702 may further include a storage device 708, such as a hard-drive or CD-ROM, for storing an operating system 722 and other related software 724, applications 720 and executable instructions. Programming environment 307 which executes in memory 706 may be provided by one or more applications 720 installed via a device readable medium 716 and stored in the storage device 708. Additionally, the operating system and the applications 720 that provide programming environment 307 may be run from a bootable CD, such as, for example, KNOPPIX®, a bootable CD for GNU/Linux.

Memory 706 may include a computer system memory or random access memory (RAM) such as dynamic random access memory (DRAM), static random access memory (SRAM), extended data out dynamic random access memory (EDO RAM), etc. Memory 706 may include other types of memory as well, or combinations thereof. Code loaded in memory 706 (which may include code for software 724 or applications 720) may run in a virtualized environment, such as in a Virtual Machine (VM) 717. Multiple VMs may be resident on a single processor. Also, part of the software 724 or applications 720 may be run in hardware, for example, by configuring a field programmable gate array (FPGA) or creating an application specific integrated circuit (ASIC). Further, part of the application may be run on analog electronic devices or other resources may be used to run part of the application, such as graphics processing units (GPUs) or dedicated hardware such as Fast Fourier Transform (FFT) processing hardware. Additionally, the computing device 702 may include a hardware accelerator 719.

A programmer may interact with computing device 702 through a display device 714 such as a computer monitor, which may be used to display a graphical user interface (GUI) 715. Computing device 702 may include other I/O devices 710 such a keyboard and/or a pointing device 712, for example a mouse, for receiving input from a user. Optionally, the I/O devices 710 and the pointing device 712 may be connected to display device 714. Additionally, computing device 702 may include any type of input device for receiving user input, such as a joystick. In other exemplary embodiments, computing device 702 may include any type of haptic or tactile feedback device, such as a vibration generating mouse, or a force feedback device such as a force feedback joystick. Also, computing device 702 may include any type of sound producing I/O device such as any suitable sound card. Computing device 702 may include other suitable conventional I/O peripherals.

Network interface 718 may include a built-in network adapter, network interface card, PCMCIA network card, card bus network adapter, wireless network adapter, USB network adapter, modem or any other device suitable for interfacing computing device 702 to any type of network capable of communication and performing the operations described herein. Moreover, the computing device 702 may be any computer system such as a workstation, desktop computer, server, laptop, handheld computer or other form of computing or telecommunications device that is capable of communication and that has sufficient processor power and memory capacity to perform the operations described herein.

FIG. 7B depicts an exemplary network environment 750 suitable for the distributed implementation of an exemplary embodiment. The network environment 750 may include one or more servers 752 and 754 coupled to clients 756 and 758 via a communication network 760. In one implementation, the servers 752 and 754 and/or the clients 756 and/or 758 may be implemented via the computing device 702. Network interface 718 of the computing device 702 enables the servers 752 and 754 to communicate with the clients 756 and 758 through the communication network 760. Communication network 760 may include Internet, intranet, LAN (Local Area Network), WAN (Wide Area Network), MAN (Metropolitan Area Network), wireless network (e.g., using IEEE 802.11 or Bluetooth), etc. In addition network 760 may use middleware, such as Common Object Request Broker Architecture (CORBA) or Distributed Component Object Model (DCOM) to allow a computing device on the network 760 to communicate directly with another computing device that is connected to network 760.

FIG. 8 depicts a system 800 for debugging a program, according to aspects of another exemplary embodiment. The system includes an electronic device 802 with a display 805 and memory 810. System 802 also includes a programming environment 815 with a presentation layer and a debugger 820. Debugger 820 includes a retrieving mechanism 825 for obtaining a portion of information from the memory, where the portion of information is a portion of the information manipulated by executable code being debugged. Retrieving mechanism 825 may include a mechanism for accessing a symbol table 66 to determine an address in memory of the portion of the information, which is an address in memory of the language-specific representation of the object. Debugger 820 also includes a first marshalling function generation mechanism 830 where the first marshalling function receives the portion of the information and produces a presentation layer representation of the portion of the information. The debugger may also include a second marshalling function generation mechanism 835 where the second marshalling function receives a presentation layer representation of information and produces corresponding information that is compatible with the executable code. The first marshalling function generation mechanism may instruct a compiler to generate at least one marshalling function. The debugger also includes a display mechanism 840 for displaying the presentation layer representation of the portion of the information to the user. Display mechanism 840 may communicate with the programming environment presentation layer to display the presentation layer representation of the portion of the information.

Although the present invention has been described with reference to the example embodiments illustrated in the figures, it should be understood that many alternative forms may embody the present invention. It is, therefore, expressly noted that the present invention is not limited to these exemplary embodiments, but rather the intention is that additions and modifications to what is expressly described herein also are included within the scope of the invention. Moreover, it is to be understood that the features of the various exemplary embodiments described herein are not mutually exclusive and may exist in various combinations and permutations, even if such combinations or permutations are not made express herein, without departing from the spirit and scope of the invention. 

What is claimed as new and desired to be protected by Letters Patent of the United States is:
 1. A method, comprising: generating, by one or more processors, using a compiler in a programming environment: executable code, where: the executable code includes one or more program objects, and at least one of the one or more program objects is associated with data, and a first marshalling function based on a request from a debugger, where the first marshalling function: receives a portion of programming-language-specific information associated with the one or more program objects of the executable code, produces a first presentation layer representation of the portion of the programming-language-specific information, the first presentation layer representation: is compatible with the debugger, and includes opaque data objects representing the data associated with the at least one of the one or more program objects of the executable code, the opaque data objects being formatted for display, the opaque data objects in a different format from the one or more program objects of the executable code, and provides the first presentation layer representation of the portion of the information to the debugger; and debugging, by the one or more processors, using the debugger, the executable code, the debugging including: interacting with a presentation layer, where the presentation layer: is external to the debugger, and is used for displaying the opaque data objects included in the first presentation layer representation of the portion of the information; sending the first presentation layer representation of the portion of the information from the debugger to the presentation layer, instructing the presentation layer to display the first presentation layer representation of the portion of the information via a display device, displaying the opaque data objects included in the first presentation layer representation of the portion of the information via the display device, the displaying: performed using the presentation layer external to the debugger, and providing the data associated with the at least one of the one or more program objects of the executable code; receiving, by the one or more processors, proposed changes to the first presentation layer representation of the portion of the information; generating, by the one or more processors, a second marshalling function as a result of the received proposed changes to the first presentation layer representation, the second marshalling function: creates a second presentation layer representation containing a second set of opaque data objects, the second presentation layer representation including the proposed changes to the first presentation layer representation, and produces a programming-language-specific representation of the second presentation layer representation; and executing, by the processors, the programming-language-specific representation of the second presentation layer representation.
 2. The method of claim 1, wherein the debugging further comprises: sending the portion of the information to a destination, wherein the portion of the information is sent using the first presentation layer representation of the portion of the information or using another representation of the portion of the information that differs from the first presentation layer representation.
 3. The method of claim 1, wherein the debugging further comprises: storing the first presentation layer representation of the portion of the information in a storage device.
 4. The method of claim 1, wherein the programming-language-specific representation of the second presentation layer is in a format compatible with the executable code.
 5. The method of claim 4, further comprising: modifying the executable code using the proposed changes.
 6. The method of claim 1, further comprising: compiling a program in a debug mode using the debugger to generate one or more marshalling functions that include the first marshalling function.
 7. The method of claim 1, wherein the debugging further comprises: displaying the first presentation layer representation of the portion of information in a graphical user interface (GUI) associated with the presentation layer.
 8. The method of claim 1, wherein: the first marshalling function accepts an address in a memory of a programming-language-specific representation of an object as an input and the first marshalling function returns a second address of a presentation layer representation of the object as output; and the second marshalling function accepts the second address of the presentation layer representation of a second object and a name of the second object as input and the second marshalling function returns a third address of the programming-language-specific representation of the second object as output.
 9. The method of claim 1, wherein the first marshalling function converts C programming language data objects into a MATLAB data format, and the second marshalling function converts data objects compatible with the MATLAB data format into C programming language data objects.
 10. The method of claim 1, wherein the first presentation layer representation and the second presentation layer representation are programming-language independent.
 11. A non-transitory computer-readable medium storing: one or more executable instructions that, when executed, cause at least one computing device to: generate, using a compiler in a programming environment: executable code, where: the executable code includes one or more program objects, and at least one of the one or more program objects is associated with data, and a first marshalling function based on a request from a debugger, where the first marshalling function: receives a portion of programming-language-specific information associated with the one or more program objects of the executable code, produces a first presentation layer representation of the portion of the programming-language-specific information, the first presentation layer representation:  is compatible with the debugger, and  includes opaque data objects representing the data associated with the at least one of the one or more program objects of the executable code, the opaque data objects being formatted for display and the opaque data objects being in a different format from the one or more objects of the executable code, and  provides the first presentation layer representation of the portion of the information to the debugger a second marshalling function as a result of receiving proposed changes to the first presentation layer representation of the portion of the information, the second marshalling function: creates a second presentation layer representation containing a second set of opaque data objects, the second presentation layer representation including the proposed changes to the first presentation layer representation, and produces a programming-language-specific representation of the second presentation layer representation; and debug, using the debugger, the executable code, the debugging including: interacting with a presentation layer, where the presentation layer: is external to the debugger, and is used for displaying the opaque data objects included in the first presentation layer representation of the portion of the information; sending the first presentation layer representation of the portion of the information from the debugger to the presentation layer, and instructing the presentation layer to display the first presentation layer representation of the portion of the information via a display device, displaying the opaque data objects included in the first presentation layer representation of the portion of the information via the display device, the displaying:  performed using the presentation layer external to the debugger, and  providing the data associated with the at least one of the one or more program objects of the executable code, receiving the proposed changes to the first presentation layer representation of the portion of the information; and execute the programming-language-specific representation of the second presentation layer representation.
 12. The medium of claim 11, wherein the instructions for debugging further cause the at least one computing device to: send the portion of the information to a destination, wherein the portion of the information is sent using the first presentation layer representation of the portion of the information or using another representation of the portion of the information that differs from the first presentation layer representation.
 13. The medium of claim 11, wherein the instructions for debugging further cause the at least one computing device to: store the first presentation layer representation of the portion of the information in a storage device.
 14. The medium of claim 11, wherein the programming-language-specific representation of the second presentation layer representation is in a format compatible with the executable code.
 15. The medium of claim 14, wherein the instructions for debugging further cause the at least one computing device to: modify the executable code using the proposed changes.
 16. The medium of claim 11, wherein the instructions when executed further cause the at least one computing device to: compile the program in a debug mode using the debugger to generate one or more marshalling functions that include the first marshalling function.
 17. The medium of claim 11, wherein the instructions for debugging when executed further cause the at least one computing device to: display the first presentation layer representation of the object in a graphical user interface (GUI) associated with the presentation layer.
 18. A system, comprising: one or more processors executing a compiler, the compiler: generating executable code, where: the executable code includes one or more program objects, and at least one of the one or more program objects is associated with data, and generating a first marshalling function based on a request from a debugger, the first marshalling function: receives a portion of programming-language-specific information associated with the one or more program objects of the executable code, produces a first presentation layer representation of the portion of the programming-language-specific information, the first presentation layer representation: is compatible with the debugger, and includes opaque data objects representing the data associated with the at least one of the one or more program objects of the executable code, the opaque data objects being formatted for display, the opaque data objects in a different format from the one or more program objects of the executable code, and provides the first presentation layer representation of the portion of the information to the debugger, generating a second marshalling function based on received proposed changes to the first presentation layer representation of the portion of the programming-language-specific information, the second marshalling function: creates a second presentation layer representation containing a second set of opaque data objects, the second presentation layer representation including the proposed changes to the first presentation layer representation, and produces a programming-language-specific representation of the second presentation layer representation; and information, and producing modified information for use by the executable code or a device; the one or more processors executing a debugger, the debugger: debugging the executable code, the debugging further including: interacting with a presentation layer, where the presentation layer: is external to the debugger, and is used for displaying the opaque data objects included in the first presentation layer representation of the portion of the information, and sending the first presentation layer representation of the portion of the information to the presentation layer, and instructing the presentation layer to display the first presentation layer representation of the portion of the information, receiving the proposed changes to the first presentation layer representation of the portion of the information; and a display device for: displaying the opaque data objects included in the first presentation layer representation of the portion of the information, the displaying: performed using the presentation layer external to the debugger, and providing the data associated with the at least one of the one or more program objects of the executable code.
 19. The system of claim 18, wherein the programming-language-specific representation of the second presentation layer representation is in a format compatible with the executable code.
 20. A system comprising: a memory storing programming-language-specific information associated with one or more program objects of an executable code; a programming environment with a presentation layer, where the presentation layer: is external to a debugger, and is used for displaying data associated with the one or more program objects of the executable code; a debugger including a retrieving mechanism for obtaining a portion of the programming-language-specific information from the memory when execution of the executable code is halted; a processor executing instructions to: generate a first marshalling function based on a request from the debugger, the first marshalling function: receives the portion of the programming-language-specific information, produces a first presentation layer representation of the portion of the programming-language-specific information, the first presentation layer representation: is compatible with the debugger, and includes opaque data objects representing the data associated with the one or more program objects of the executable code, the opaque data objects being formatted for display, the opaque data objects being in a different format from the one or more objects of the executable code, and provides the presentation layer representation of the portion of the information to the debugger, generate a second marshalling function as a result of receiving proposed changes to the first presentation layer representation, the second marshalling function: creates a second presentation layer representation containing a second set of opaque data objects, the second presentation layer representation including the proposed changes to the first presentation layer representation, and produces a programming-language-specific representation of the second presentation layer representation; and a display mechanism to display the opaque data objects included in the first presentation layer representation of the portion of the information, the display mechanism receives the first presentation layer representation of the portion of the information from the debugger via the presentation layer, and the displaying: performed using the presentation layer external to the debugger, and providing the data associated with the one or more program objects of the executable code.
 21. The system of claim 20, wherein the programming-language-specific representation of the second presentation layer representation is compatible with the executable code.
 22. The system of claim 20, wherein the display mechanism is a graphical user interface associated with the presentation layer. 